package Test_0508;

import javax.swing.*;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Created with Intellij IDEA
 * Description:
 * User: 星辰
 * Dare: 2024-05-07
 * Time: 23:54
 */
public class Tset_0508 {
   /* 调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
    如数组：[1,2,3,4,5,6]
    调整后可能是：[1, 5, 3, 4, 2, 6]*/
   public static void main(String[] args) {
       int[] num=new int[]{1,7,4,5,3,2};
       int left=0;
       int right=num.length-1;
       for (int i= num.length-1;i>0;i--) {
           if(num[left]%2==1){
               left++;
               continue;
           }
           if(num[right]%2==1){
               int tmp=0;
               tmp=num[right];
               num[right]=num[left];
               num[left]=tmp;
               left++;
               right--;
           }
       }
       System.out.println(Arrays.toString(num));
   }
   /* 给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
    示例 1：
    输入：arr = [2,6,4,1]
    输出：false
    解释：不存在连续三个元素都是奇数的情况。
    示例 2：
    输入：arr = [1,2,34,3,4,5,7,23,12]
    输出：true
    解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。*/
   public static void main8(String[] args) {
       int[] arr=new int[]{1,2,34,3,4,5,7,23,12};
       boolean flag=false;
       int tmp=-1;
       for (int i = 0; i < arr.length-2; i++) {
           tmp++;
           flag=false;
           int sum=0;
           for (int j = tmp; j < tmp+3; j++) {
               if(arr[j]%2==1){
                  sum++;
              }
              else{
                  continue;
              }
           }
           if(sum==3){
               flag =true;
               break;
           }
       }
       System.out.println(flag);
   }
  /*  给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    你可以假设数组是非空的，并且给定的数组总是存在多数元素。*/
  public static void main7(String[] args) {
      int[] num=new int[]{1,1,1,2,2,2,2,2,3};
      for (int i = 0; i < num.length; i++) {

      }
  }
    //数组的输入
  public static void main6(String[] args) {
      Scanner sc = new Scanner(System.in);
      String str = sc.nextLine().toString();
      String[] arr=str.split(" ");
      int[] b=new int[arr.length];
      for(int i=0;i<b.length;i++){
          b[i]=Integer.parseInt(arr[i]);
          System.out.println(b[i]);
      }
  }

    /*给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。*/
    public static void main5(String[] args) {
        int[] num=new int[]{1,2,3,4,2,5,3,4,1};
        int n=0;
        for (int i = 0; i < num.length ; i++) {
            n ^=num[i];
        }
        System.out.println(n);
    }
    /*给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    你可以按任意顺序返回答案。
    示例 1：
    输入：nums = [2,7,11,15], target = 9
    输出：[0,1]
    解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。*/
    public static int[] sum(int[] nums,int target) {
        int[] flag=new int[2];
        int tmp=0;
        int rec=0;
        for (int i=rec; i < nums.length; i++) {
              tmp++;
            for (int j = tmp; j <nums.length ; j++) {
                int sum=nums[i]+nums[j];
                if(sum==target) {
                    flag[0] = i;
                    flag[1] = j;
                }
            }
            rec++;
            }
        return flag;
    }

    public static void main4(String[] args) {
        int[] nums=new int[]{2,7,1,15};
        System.out.println(Arrays.toString(sum(nums,8)));
    }
    /*给定一个整型数组, 实现冒泡排序(升序排序)*/
        public static void bubbleSort(int[] array) {
            int len=array.length;
            boolean flg=false;
            for (int i = 0; i < len-1; i++) {
                for (int j = 0; j <len-1-i;j++) {
                    if(array[j]>array[j+1]){
                        int tmp=0;
                        tmp=array[j+1];
                        array[j+1]=array[j];
                        array[j]=tmp;
                        flg=false;
                    }
                    else{
                        flg=true;
                    }
                }
                if(flg==true) {
                    return ;
                }
            }
        }
    public static void main3(String[] args) {
        int[] array=new int[]{1,6,3,4,8,9};
        System.out.println(Arrays.toString(array));
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
   /*给定一个有序整型数组, 实现二分查找*/
   public static int find(int key,int[] array) {
       int left=0;
       int right=array.length-1;
       int mid=0;
       boolean flg=false;
       while(left<=right) {
           mid=(left+right)/2;
           if(array[mid]<key){
               left=mid+1;
           }
           else if(array[mid]>key){
               right=mid-1;
           }
           else{
               flg=true;
               return mid;
           }
       }
       if (flg==false){
           System.out.println("找不到");
       }
       return -1;
   }
    public static void main2(String[] args) {
           int[] array=new int[]{1,3,4,5,7,9};
        System.out.println(find(5,array));
    }
        /* 实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上.
    例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}*/
        public static int[] transform(int[] array) {
            int[] copy=new int[array.length];
            for (int i = 0; i < array.length; i++) {
                copy[i]=array[i]*2;
            }
            return copy;
        }
        public static void main1(String[] args) {
            int[] array=new int[]{1,2,3};
            int []array1={1,2,3};
            System.out.println(transform(array));//地址
            System.out.println(Arrays.toString(array));//内容
            System.out.println(Arrays.toString(transform(array)));
            System.out.println(array.length);
        }
}
